package com.yidu.hbatsams.action;

import com.yidu.hbatsams.domain.*;
import com.yidu.hbatsams.domain.vo.UserVo;
import com.yidu.hbatsams.service.*;
import com.yidu.hbatsams.service.emp.AtsEmpAthleteService;
import com.yidu.hbatsams.service.emp.AtsEmpExpertService;
import com.yidu.hbatsams.utils.FileTools;
import com.yidu.hbatsams.utils.Message;
import net.minidev.json.JSONObject;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.*;

/**
 * @描述：方案Action
 * @backage:com.yidu.hbatsams.action
 * @Author: 冯双
 * @Date: 2019/11/30
 **/
@Controller
@RequestMapping("AtsSchemeFsController")
public class AtsSchemeFsController {
    Logger logger = Logger.getLogger(getClass());
    /**
     * 方案service接口
     */
    @Resource
    AtsSchemeFsService atsSchemeFsService;

    /**
     * 专家咨询Service接口
     */
    @Resource
    AtsSchemeExpertFsService atsSchemeExpertFsService;

    /**
     * 审核表Service
     */
    @Resource
    AtsSchemeAuditFsService atsSchemeAuditFsService;

    /**
     * 专家Service接口
     */
    @Resource
    AtsEmpExpertService atsEmpExpertService;

    /**
     * 方案和运动员关联Service
     */
    @Resource
    AtsSchemeAthleteFsService atsSchemeAthleteFsService;

    /**
     * 运动员service接口
     */
    @Resource
    AtsEmpAthleteService atsEmpAthleteService;

    /**
     * 文件上传管理工具
     */
    @Resource
    FileTools fileTools;

    public AtsSchemeAuditFsService getAtsSchemeAuditFsService() {
        return atsSchemeAuditFsService;
    }

    public void setAtsSchemeAuditFsService(AtsSchemeAuditFsService atsSchemeAuditFsService) {
        this.atsSchemeAuditFsService = atsSchemeAuditFsService;
    }

    public AtsSchemeExpertFsService getAtsSchemeExpertFsService() {
        return atsSchemeExpertFsService;
    }

    public void setAtsSchemeExpertFsService(AtsSchemeExpertFsService atsSchemeExpertFsService) {
        this.atsSchemeExpertFsService = atsSchemeExpertFsService;
    }

    public AtsSchemeFsService getAtsSchemeFsService() {
        return atsSchemeFsService;
    }

    public void setAtsSchemeFsService(AtsSchemeFsService atsSchemeFsService) {
        this.atsSchemeFsService = atsSchemeFsService;
    }

    /**
     * 查询所有的方案
     * @param session HttpSession对象
     * @param atsScheme 方案的对象
     * @param pageNum 当前页
     * @param pageSize 长度
     * @return 方案的集合
     */
    @ResponseBody
    @RequestMapping("selectAll")
    public Map<String, Object> selectAll(HttpSession session,AtsScheme atsScheme,@RequestParam("page") Integer pageNum,@RequestParam("limit") Integer pageSize) {
        //创建map集合
        Map<String,Object> map = new HashMap<>();
        //获取user对象
        UserVo user = (UserVo) session.getAttribute("user");
        //创建AtsScheme的list集合
        List<AtsScheme> list=new ArrayList<AtsScheme>();
        //创建count
        int count=0;
        //判断是不是超级管理员
        if("superman".equals(user.getStandbyThree())){
            System.out.println("===========超级管理员==========");
            //调用查询所有的方法
            list=atsSchemeFsService.selectAll(atsScheme,pageNum,pageSize);
            //查询方案的审核状态赋值在remark
            list=setRemark(list);
            //调用查询分页的方法
            count=atsSchemeFsService.selectAllFsCount(atsScheme);
        //判断是否为1(领导)
        }else if("1".equals(user.getCompanyId())){
            System.out.println("===========领导==========");
            //调用查询所有的方法
            list=atsSchemeFsService.selectAuditAllFs(atsScheme,pageNum,pageSize);
            //查询方案的审核状态赋值在remark
            list=setRemark(list);
            //调用查询分页的方法
            count=atsSchemeFsService.selectAuditAllFsCount(atsScheme);
        //判断是否为2(教练员)
        }else if("2".equals(user.getCompanyId())){
            System.out.println("===========教练员==========");
            //方案的教练id赋值
            atsScheme.setCoachId(Integer.valueOf(user.getClerkId()));
            //调用查询所有的方法
            list=atsSchemeFsService.selectAll(atsScheme,pageNum,pageSize);
            //查询方案的审核状态赋值在remark
            list=setRemark(list);
            //调用查询分页的方法
            count=atsSchemeFsService.selectAllFsCount(atsScheme);
        //判断是否为3(专家)
        }else if("3".equals(user.getCompanyId())){
            System.out.println("===========专家==========");
            //方案的setRemark赋值
            atsScheme.setRemark(user.getClerkId());
            //调用查询所有的方法
            list=atsSchemeFsService.selectExpertAllFs(atsScheme,pageNum,pageSize);
            //查询方案的审核状态赋值在remark
            list=setRemark(list);
            //调用查询分页的方法
            count=atsSchemeFsService.selectExpertAllFsCount(atsScheme);
        //判断是否为4(运动员)
        }else if("4".equals(user.getCompanyId())){
            System.out.println("===========运动员==========");
            //方案的setRemark赋值
            atsScheme.setRemark(user.getClerkId());
            //调用查询所有的方法
            list=atsSchemeFsService.selectAthleteAllFs(atsScheme,pageNum,pageSize);
            //查询方案的审核状态赋值在remark
            list=setRemark(list);
            //调用查询分页的方法
            count=atsSchemeFsService.selectAthleteAllFsCount(atsScheme);
        }
        //给map赋值code,msg,count,data
        map.put("code", 0);
        map.put("msg", "");
        map.put("count",count);
        map.put("data", list);
        //传出map集合
        return map;
    }

    /**
     * 增加方案审核状态方法
     * @param list 方案的集合
     * @return 方案的集合
     */
    public List<AtsScheme> setRemark(List<AtsScheme> list){
        //循环list集合
        for (int i = 0; i < list.size(); i++) {
            //获取当前对象
            AtsScheme scheme =  list.get(i);
            //调用专家咨询表根据方案id查询的方法
            AtsSchemeExpert atsSchemeExpert=atsSchemeExpertFsService.selectBySchemeId(scheme.getSchemeId());
            //判断对象如果不为空
            if(atsSchemeExpert!=null){
                //将专家咨询表中的审核状态赋值到方案的remark中
                scheme.setRemark(atsSchemeExpert.getAuditState());
                //判断专家id不为空
                if(atsSchemeExpert.getExpertId()!=null && !"".equals(atsSchemeExpert.getExpertId())){
                    //将专家id赋值到方案的sort中
                    scheme.setSort(Integer.valueOf(atsSchemeExpert.getExpertId()));
                }
            }
        }
        //返回list集合
        return list;
    }


    /**
     * 方案表新增或修改方法
     * @param formData 方案对象
     * @param session HttpSession对象
     * @return 返回msg对象
     */
    @ResponseBody
    @RequestMapping("addAndUpdate")
    public Message updateByPrimaryKey(AtsScheme formData,HttpSession session){
        //创建rows,msg对象
        int rows=0;
        Message msg = new Message();
        //判断方案id为空
        if (formData.getSchemeId()==null){
            //获取user对象
            UserVo user = (UserVo) session.getAttribute("user");
            //判断是超级管理员
            if("superman".equals(user.getStandbyThree())){
                //教练员id赋值为0
                formData.setCoachId(0);
                //教练员姓名为user姓名
                formData.setCoachName(user.getUserName());
            }else{
                //将对象id赋值到教练员id
                formData.setCoachId(new Integer(user.getClerkId()));
                //将对象名字赋值到教练员名字
                formData.setCoachName(user.getClerkName());
            }
            //给创建人赋值
            formData.setCreater(user.getUserName());
            //赋值为有效
            formData.setIsva(1);
            //调用新增方法
            rows =atsSchemeFsService.insert(formData);
        //判断方案id不为空或大于0
        }else if(formData.getSchemeId()!=null&&formData.getSchemeId()>0){
            //获取user对象
            UserVo user = (UserVo) session.getAttribute("user");
            //给创建人赋值
            formData.setCreater(user.getUserName());
            //调用方案表修改方法
            rows = atsSchemeFsService.updateByPrimaryKeySelective(formData);
            //调用专家咨询表，审核表修改名字的方法
            atsSchemeExpertFsService.updateSchemeName(formData.getSchemeId(),formData.getSchemeName());
            atsSchemeAuditFsService.updateSchemeName(formData.getSchemeId(),formData.getSchemeName());

        }
        if (rows>0){
            msg.setNum(1);
            msg.setMsg("操作成功");
        }else{
            msg.setNum(0);
            msg.setMsg("操作失败");
        }
        return msg;
    }


    /**
     * 根据schemeId查询方案表
     * @param schemeId 方案表id
     * @return AtsScheme对象
     */
    @ResponseBody
    @RequestMapping("selectByPrimaryKey")
    public AtsScheme selectByPrimaryKey(int schemeId) {
        //调用方案表根据id查询
        AtsScheme atsScheme=atsSchemeFsService.selectByPrimaryKey(schemeId);
        return atsScheme;
    }

    @ResponseBody
    @RequestMapping("deleteByPrimaryKey")
    public Message deleteByPrimaryKey(int schemeId) {
        //创建msg对象
        Message msg = new Message();
        msg.setNum(1);
        //调用根据id删除的方法
        atsSchemeFsService.deleteByPrimaryKey(schemeId);
        atsSchemeExpertFsService.deleteScheme(schemeId);
        atsSchemeAuditFsService.deleteScheme(schemeId);
        atsSchemeAthleteFsService.updateIsva(schemeId);
        msg.setMsg("删除成功");
        return msg;
    }

    /**
     * 批量删除
     * @param schemeIds 方案id组成的字符串
     * @return msg对象
     */
    @ResponseBody
    @RequestMapping("deleteMany")
    public Message deleteMany(String schemeIds) {
        //创建字符串数组
        String[] ids = null;
        //创建msg对象
        Message msg = new Message();
        msg.setNum(1);
        //如果传过来的对象不为空
        if(schemeIds!=null&&!"".equals(schemeIds)){
            //根据，分割
            ids=schemeIds.split(",");
        }
        //循环遍历ids
        for (int i = 0; i < ids.length; i++) {
            //获取当前方案id
            String schemeId = ids[i];
            //调用删除的方法
            atsSchemeFsService.deleteByPrimaryKey(Integer.valueOf(schemeId));
            atsSchemeExpertFsService.deleteScheme(Integer.valueOf(schemeId));
            atsSchemeAuditFsService.deleteScheme(Integer.valueOf(schemeId));
            atsSchemeAthleteFsService.updateIsva(Integer.valueOf(schemeId));
        }
        msg.setMsg("删除成功");
        return msg;
    }

    /**
     * 修改反馈
     * @param formData 方案对象
     * @return msg对象
     */
    @ResponseBody
    @RequestMapping("feedbackAddAndUpdate")
    public Message FeedbackAddAndUpdate(AtsScheme formData){
        //创建rows，msg对象
        int rows=0;
        Message msg = new Message();
        //调用修改方法
        rows = atsSchemeFsService.feedbackUpdateByPrimaryKeySelective(formData);
        if (rows>0){
            msg.setNum(1);
            msg.setMsg("操作成功");
        }else{
            msg.setNum(0);
            msg.setMsg("操作失败");
        }
        return msg;
    }

    /**
     * 根据seId查询专家咨询表
     * @param seId 专家咨询表主键
     * @return 专家咨询表对象
     */
    @ResponseBody
    @RequestMapping("selectExpertBySeId")
    public AtsSchemeExpert selectExpertBySeId(int seId) {
        //调用根据seid查询的方法
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertFsService.selectExpertBySeId(seId);
        return atsSchemeExpert;
    }

    /**
     * 根据saId查询专家咨询表
     * @param saId 方案表外键
     * @return 专家咨询表对象
     */
    @ResponseBody
    @RequestMapping("selectExpertBySaId")
    public AtsSchemeExpert selectExpertBySaId(Integer saId) {
        //调用根据said查询的方法
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertFsService.selectExpertBySaId(saId);
        return atsSchemeExpert;
    }


    /**
     * 根据saId查询审核表
     * @param saId 方案表外键
     * @return 审核表对象
     */
    @ResponseBody
    @RequestMapping("selectAuditBySaId")
    public AtsSchemeAudit selectAuditBySaId(String saId) {
        ////调用根据said查询的方法
        AtsSchemeAudit atsSchemeAudit=atsSchemeAuditFsService.selectAuditBySaId(saId);
        return atsSchemeAudit;
    }

    /**
     *根据主键查询审核表
     * @param auId 审核表主键
     * @return 审核表对象
     */
    @ResponseBody
    @RequestMapping("selectAuditByAuId")
    public AtsSchemeAudit selectAuditByAuId(int auId) {
        ////调用根据auid查询的方法
        AtsSchemeAudit atsSchemeAudit=atsSchemeAuditFsService.selectByPrimaryKey(auId);
        return atsSchemeAudit;
    }


    /**
     * 查询当前教练手下所有运动员
     * @param session HttpSession对象
     * @return 运动员集合
     */
    @ResponseBody
    @RequestMapping("selectAthlete")
    public List<AtsEmpAthlete> selectAthlete(HttpSession session){
        //获取user对象
        UserVo user = (UserVo) session.getAttribute("user");
        //创建AtsEmpAthlete的list集合
        List<AtsEmpAthlete> empAthleteList=new ArrayList<AtsEmpAthlete>();
        //判断是不是超级管理员
        if("superman".equals(user.getStandbyThree())){
            //创建AtsEmpAthlete对象
            AtsEmpAthlete atsEmpAthlete=new AtsEmpAthlete();
            //调用查询所有运动员
            empAthleteList =atsEmpAthleteService.findAll(atsEmpAthlete);
        }else{
            //查询运动员与教练员关联的集合
            empAthleteList=atsEmpAthleteService.selectByCoachId(Integer.valueOf(user.getClerkId()));
        }
        return empAthleteList;
    }

    /**
     * 查询方案对应的所有运动员
     * @param schemeId 方案表外键
     * @returnl 方案运动员表集合
     */
    @ResponseBody
    @RequestMapping("selectCheckAthlete")
    public List<AtsSchemeAthlete> selectCheckAthlete(Integer schemeId){
        //调用选择运动员的方法
        List<AtsSchemeAthlete> list=atsSchemeAthleteFsService.selectCheckAthlete(schemeId);
        return list;
    }


    /**
     * 上传文件
     * @param file 文件
     * @return json对象
     */
    @RequestMapping("/uploadFile")
    @ResponseBody
    public JSONObject uploadFile(@RequestParam("file") MultipartFile file){
        //新建一个日历对象
        Calendar cale = Calendar.getInstance();
        //创建json对象
        JSONObject json = new JSONObject();
        try{
            //创建字符串对象
            String filePath = null;
            //判断
            if (!file.isEmpty()) {
                //给路径赋值
                filePath = fileTools.saveFile("user/atsScheme",file);
            }
            //返回json
            json.put("msg",filePath);
            json.put("code",0);
        }catch(Exception e){
            e.printStackTrace();
            json.put("msg","上传失败");
            json.put("code",0);
        }
        return json;
    }


    /**
     * 查询专家
     * @return 专家集合
     */
    @ResponseBody
    @RequestMapping("selectExpert")
    public List<AtsEmpExpert> findExpert(){
        //调用查询专家方法
        List<AtsEmpExpert> list = atsEmpExpertService.selectExpert();
        return list;
    }

    /**
     * 审核表的新增或修改
     * @param formData 审核表对象
     * @return msg对象
     */
    @ResponseBody
    @RequestMapping("UpdateAudit")
    public Message UpdateAudit(AtsSchemeAudit formData) {
        //创建专家咨询表对象
        AtsSchemeExpert atsSchemeExpert = new AtsSchemeExpert();
        //给SchemeId赋值
        atsSchemeExpert.setSchemeId(new Integer(formData.getSaId()));
        //判断状态是否为20
        if (Integer.valueOf(formData.getAuditState()) == 20){
            //给ExpertId赋值
            atsSchemeExpert.setExpertId(formData.getExpertId());
            //调用根据ExpertId查询的方法
            AtsEmpExpert atsEmpExpert=atsEmpExpertService.selectByPrimaryKey(formData.getExpertId());
            //给ExpertName赋值
            atsSchemeExpert.setExpertName(atsEmpExpert.getExpertName());
        }
        //给状态赋值
        atsSchemeExpert.setAuditState(formData.getAuditState());
        //调用审核表根据SaId查询方法
        AtsSchemeAudit atsSchemeAudit=atsSchemeAuditFsService.selectAuditBySaId(formData.getSaId());
        //判断对象非空
        if(atsSchemeAudit!=null){
            //调用修改方法
            atsSchemeAuditFsService.updateByPrimaryKeySelectiveFs(formData);
        }else{
            //调用新增方法
            atsSchemeAuditFsService.insertSelective(formData);
        }
        //创建msg对象
        Message msg = new Message();
        msg.setNum(1);
        //调用专家咨询表修改方法
        atsSchemeExpertFsService.updateBySaId(atsSchemeExpert);
        msg.setMsg("操作成功");
        return msg;
    }

    /**
     * 修改专家咨询表中的回复
     * @param formData 回复对象
     * @return 忙对象
     */
    @ResponseBody
    @RequestMapping("UpdateReply")
    public Message UpdateReply(AtsSchemeExpert formData) {
        int rows = 0;
        //调用专家咨询表修改方法
        rows = atsSchemeExpertFsService.updateByPrimaryKeySelective(formData);
        //调用审核表修改状态的方法
        atsSchemeAuditFsService.updateAuditState(String.valueOf(formData.getSchemeId()),"40");
        //创建msg对象
        Message msg = new Message();
        if (rows > 0) {
            msg.setNum(1);
            msg.setMsg("操作成功");
        } else {
            msg.setNum(0);
            msg.setMsg("操作失败");
        }
        return msg;
    }


    /**
     * 查询选中的运动员
     * @param schemeId 方案表外键
     * @return 方案运动员集合
     */
    @ResponseBody
    @RequestMapping("selectAthleteById")
    public List<AtsSchemeAthlete> selectAthleteById(Integer schemeId){
        //查询选中的运动员
        return atsSchemeAthleteFsService.selectCheckAthlete(schemeId);
    }

    /**
     * 根据运动员查看他的意见
     * @param schemeId 方案表外键
     * @param session HttpSession对象
     * @return
     */
    @ResponseBody
    @RequestMapping("selectExp")
    public AtsSchemeAthlete selectExp(Integer schemeId,HttpSession session){
        //获取user对象
        UserVo user = (UserVo) session.getAttribute("user");
        //判断CompanyId等于4
        if(user.getCompanyId()=="4"||"4".equals(user.getCompanyId())){
            //创建方案运动员对象
            AtsSchemeAthlete record = new AtsSchemeAthlete();
            //给AthleteId赋值
            record.setAthleteId(Integer.valueOf(user.getClerkId()));
            //给SchemeId赋值
            record.setSchemeId(schemeId);
            //调用查看意见方法
            return atsSchemeAthleteFsService.selectExp(record);
        }
        return null;
    }

    /**
     * 新增意见
     * @param schemeId 方案表外键
     * @param exp 意见
     * @param session HttpSession对象
     * @return
     */
    @ResponseBody
    @RequestMapping("addAthleteExp")
    public Message addAthleteExp(Integer schemeId,String exp,HttpSession session){
        //获取user对象
        UserVo user = (UserVo) session.getAttribute("user");
        //创建rows,msg
        int rows=0;
        Message msg = new Message();
        //创建方案运动员对象
        AtsSchemeAthlete record = new AtsSchemeAthlete();
        //给AthleteId赋值
        record.setAthleteId(Integer.valueOf(user.getClerkId()));
        //给schemeId赋值
        record.setSchemeId(schemeId);
        //给exp赋值
        record.setExp(exp);
        //调用新增意见方法
        rows=atsSchemeAthleteFsService.addAthleteExp(record);
        if (rows>0){
            msg.setNum(1);
            msg.setMsg("操作成功");
        }else{
            msg.setNum(0);
            msg.setMsg("操作失败");
        }
        return msg;
    }


    /**
     * 运动员是否查看
     * @param schemeId 方案表外键
     * @param session HttpSession对象
     * @return int
     */
    @ResponseBody

    @RequestMapping("selectLook")
    public int selectLook(Integer schemeId,HttpSession session){
        //获取user对象
        UserVo user = (UserVo) session.getAttribute("user");
        //判断CompanyId等于4
        if(user.getCompanyId()=="4"||"4".equals(user.getCompanyId())){
            //创建方案运动员对象
            AtsSchemeAthlete record = new AtsSchemeAthlete();
            //给AthleteId赋值
            record.setAthleteId(Integer.valueOf(user.getClerkId()));
            //给schemeId赋值
            record.setSchemeId(schemeId);
            //调用是否查看方法
            return atsSchemeAthleteFsService.lookAthlete(record);
        }
        return 0;
    }


    /**
     * 修改专家咨询表
     * @param formData 专家咨询表对象
     * @param session  HttpSession对象
     * @return msg对象
     */
    @ResponseBody
    @RequestMapping("addAndUpdateExpert")
    public Message updateExpertByPrimaryKey(AtsSchemeExpert formData, HttpSession session){
        //创建rows，msg
        int rows=0;
        Message msg = new Message();
        //判断seid为空
        if (formData.getSeId()==null){
            //获取user对象
            UserVo user = (UserVo) session.getAttribute("user");
            //给Creater赋值
            formData.setCreater(user.getUserName());
            //设置为有效
            formData.setIsva(1);
            //调用方案专家表的新增方法
            rows =atsSchemeExpertFsService.insertSelective(formData);
        //判断seid非空或大于0
        }else if(formData.getSeId()!=null&&formData.getSeId()>0){
            //赋值状态为10
            formData.setAuditState("10");
            //调用修改方法
            rows = atsSchemeExpertFsService.updateByPrimaryKeySelective(formData);
            //调用方案专家表的感觉seid查询方法
            AtsSchemeExpert atsSchemeExpert=atsSchemeExpertFsService.selectByPrimaryKey(formData.getSeId());
            //创建schemeId字符串对象，并赋值
            String schemeId = String.valueOf(atsSchemeExpert.getSchemeId());
            //调用审核表修改状态方法
            atsSchemeAuditFsService.updateAuditState(schemeId,String.valueOf(10));
        }
        if (rows>0){
            msg.setNum(1);
            msg.setMsg("操作成功");
        }else{
            msg.setNum(0);
            msg.setMsg("操作失败");
        }
        return msg;
    }


    /**
     * 根据schemeId查询专家咨询表
     * @param schemeId 方案外键
     * @return 专家咨询表对象
     */
    @ResponseBody
    @RequestMapping("selectBySchemeIdExpert")
    public AtsSchemeExpert selectExpertBySchemeId(int schemeId) {
        //调用查询专家方法
        AtsSchemeExpert atsSchemeExpert=atsSchemeExpertFsService.selectBySchemeId(schemeId);
        return atsSchemeExpert;
    }
}
